if (!dojo._hasResource["dojo._base.connect"]) { //_hasResource checks added by build. Do not use _hasResource directly in your code.
    dojo._hasResource["dojo._base.connect"] = true;
    dojo.provide("dojo._base.connect");
    dojo.require("dojo._base.lang");

    // this file courtesy of the TurboAjax Group, licensed under a Dojo CLA

    // low-level delegation machinery
    dojo._listener = {
        // create a dispatcher function
        getDispatcher: function() {
            // following comments pulled out-of-line to prevent cloning them
            // in the returned function.
            // - indices (i) that are really in the array of listeners (ls) will
            //   not be in Array.prototype. This is the 'sparse array' trick
            //   that keeps us safe from libs that take liberties with built-in
            //   objects
            // - listener is invoked with current scope (this)
            return function() {
                var ap = Array.prototype, c = arguments.callee, ls = c._listeners, t = c.target;
                // return value comes from original target function
                var r = t && t.apply(this, arguments);
                // invoke listeners after target function
                for (var i in ls) {
                    if (!(i in ap)) {
                        ls[i].apply(this, arguments);
                    }
                }
                // return value comes from original target function
                return r;
            }
        },
        // add a listener to an object
        add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener) {
            // Whenever 'method' is invoked, 'listener' will have the same scope.
            // Trying to supporting a context object for the listener led to
            // complexity.
            // Non trivial to provide 'once' functionality here
            // because listener could be the result of a dojo.hitch call,
            // in which case two references to the same hitch target would not
            // be equivalent.
            source = source || dojo.global;
            // The source method is either null, a dispatcher, or some other function
            var f = source[method];
            // Ensure a dispatcher
            if (!f || !f._listeners) {
                var d = dojo._listener.getDispatcher();
                // original target function is special
                d.target = f;
                // dispatcher holds a list of listeners
                d._listeners = [];
                // redirect source to dispatcher
                f = source[method] = d;
            }
            // The contract is that a handle is returned that can
            // identify this listener for disconnect.
            //
            // The type of the handle is private. Here is it implemented as Integer.
            // DOM event code has this same contract but handle is Function
            // in non-IE browsers.
            //
            // We could have separate lists of before and after listeners.
            return f._listeners.push(listener);
            /*Handle*/
        },
        // remove a listener from an object
        remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle) {
            var f = (source || dojo.global)[method];
            // remember that handle is the index+1 (0 is not a valid handle)
            if (f && f._listeners && handle--) {
                delete f._listeners[handle];
            }
        }
    };

    // Multiple delegation for arbitrary methods.

    // This unit knows nothing about DOM,
    // but we include DOM aware
    // documentation and dontFix
    // argument here to help the autodocs.
    // Actual DOM aware code is in event.js.

    dojo.connect = function(/*Object|null*/ obj,
        /*String*/ event,
        /*Object|null*/ context,
        /*String|Function*/ method,
        /*Boolean*/ dontFix) {
        // summary:
        //		Create a link that calls one function when another executes.
        //
        // description:
        //		Connects method to event, so that after event fires, method
        //		does too. All connected functions are passed the same arguments as
        //		the event function was initially called with. You may connect as
        //		many methods to event as needed.
        //
        //		event must be a string. If obj is null, dojo.global is used.
        //
        //		null arguments may simply be omitted.
        //
        //		obj[event] can resolve to a function or undefined (null).
        //		If obj[event] is null, it is assigned a function.
        //
        //		The return value is a handle that is needed to
        //		remove this connection with dojo.disconnect.
        //
        // obj:
        //		The source object for the event function.
        //		Defaults to dojo.global if null.
        //		If obj is a DOM node, the connection is delegated
        //		to the DOM event manager (unless dontFix is true).
        //
        // event:
        //		String name of the event function in obj.
        //		I.e. identifies a property obj[event].
        //
        // context:
        //		The object that method will receive as "this".
        //
        //		If context is null and method is a function, then method
        //		inherits the context of event.
        //
        //		If method is a string then context must be the source
        //		object object for method (context[method]). If context is null,
        //		dojo.global is used.
        //
        // method:
        //		A function reference, or name of a function in context.
        //		The function identified by method fires after event does.
        //		method receives the same arguments as the event.
        //		See context argument comments for information on method's scope.
        //
        // dontFix:
        //		If obj is a DOM node, set dontFix to true to prevent delegation
        //		of this connection to the DOM event manager.
        //
        // example:
        //		When obj.onchange(), do ui.update():
        //	|	dojo.connect(obj, "onchange", ui, "update");
        //	|	dojo.connect(obj, "onchange", ui, ui.update); // same
        //
        // example:
        //		Using return value for disconnect:
        //	|	var link = dojo.connect(obj, "onchange", ui, "update");
        //	|	...
        //	|	dojo.disconnect(link);
        //
        // example:
        //		When onglobalevent executes, watcher.handler is invoked:
        //	|	dojo.connect(null, "onglobalevent", watcher, "handler");
        //
        // example:
        //		When ob.onCustomEvent executes, customEventHandler is invoked:
        //	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
        //	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
        //
        // example:
        //		When ob.onCustomEvent executes, customEventHandler is invoked
        //		with the same scope (this):
        //	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
        //	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
        //
        // example:
        //		When globalEvent executes, globalHandler is invoked
        //		with the same scope (this):
        //	|	dojo.connect(null, "globalEvent", null, globalHandler);
        //	|	dojo.connect("globalEvent", globalHandler); // same

        // normalize arguments
        var a = arguments, args = [], i = 0;
        // if a[0] is a String, obj was ommited
        args.push(dojo.isString(a[0]) ? null : a[i++], a[i++]);
        // if the arg-after-next is a String or Function, context was NOT omitted
        var a1 = a[i + 1];
        args.push(dojo.isString(a1) || dojo.isFunction(a1) ? a[i++] : null, a[i++]);
        // absorb any additional arguments
        for (var l = a.length; i < l; i++) {
            args.push(a[i]);
        }
        // do the actual work
        return dojo._connect.apply(this, args);
        /*Handle*/
    }

    // used by non-browser hostenvs. always overriden by event.js
    dojo._connect = function(obj, event, context, method) {
        var l = dojo._listener, h = l.add(obj, event, dojo.hitch(context, method));
        return [obj, event, h, l]; // Handle
    }

    dojo.disconnect = function(/*Handle*/ handle) {
        // summary:
        //		Remove a link created by dojo.connect.
        // description:
        //		Removes the connection between event and the method referenced by handle.
        // handle:
        //		the return value of the dojo.connect call that created the connection.
        if (handle && handle[0] !== undefined) {
            dojo._disconnect.apply(this, handle);
            // let's not keep this reference
            delete handle[0];
        }
    }

    dojo._disconnect = function(obj, event, handle, listener) {
        listener.remove(obj, event, handle);
    }

    // topic publish/subscribe

    dojo._topics = {};

    dojo.subscribe =
    function(/*String*/ topic, /*Object|null*/ context, /*String|Function*/ method) {
        //	summary:
        //		Attach a listener to a named topic. The listener function is invoked whenever the
        //		named topic is published (see: dojo.publish).
        //		Returns a handle which is needed to unsubscribe this listener.
        //	context:
        //		Scope in which method will be invoked, or null for default scope.
        //	method:
        //		The name of a function in context, or a function reference. This is the function that
        //		is invoked when topic is published.
        //	example:
        //	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
        //	|	dojo.publish("alerts", [ "read this", "hello world" ]);

        // support for 2 argument invocation (omitting context) depends on hitch
        return [topic, dojo._listener.add(dojo._topics, topic, dojo.hitch(context, method))];
        /*Handle*/
    }

    dojo.unsubscribe = function(/*Handle*/ handle) {
        //	summary:
        //	 	Remove a topic listener.
        //	handle:
        //	 	The handle returned from a call to subscribe.
        //	example:
        //	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
        //	|	...
        //	|	dojo.unsubscribe(alerter);
        if (handle) {
            dojo._listener.remove(dojo._topics, handle[0], handle[1]);
        }
    }

    dojo.publish = function(/*String*/ topic, /*Array*/ args) {
        //	summary:
        //	 	Invoke all listener method subscribed to topic.
        //	topic:
        //	 	The name of the topic to publish.
        //	args:
        //	 	An array of arguments. The arguments will be applied
        //	 	to each topic subscriber (as first class parameters, via apply).
        //	example:
        //	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
        //	|	dojo.publish("alerts", [ "read this", "hello world" ]);

        // Note that args is an array, which is more efficient vs variable length
        // argument list.  Ideally, var args would be implemented via Array
        // throughout the APIs.
        var f = dojo._topics[topic];
        if (f) {
            f.apply(this, args || []);
        }
    }

    dojo.connectPublisher = function(/*String*/ topic,
        /*Object|null*/ obj,
        /*String*/ event) {
        //	summary:
        //	 	Ensure that everytime obj.event() is called, a message is published
        //	 	on the topic. Returns a handle which can be passed to
        //	 	dojo.disconnect() to disable subsequent automatic publication on
        //	 	the topic.
        //	topic:
        //	 	The name of the topic to publish.
        //	obj:
        //	 	The source object for the event function. Defaults to dojo.global
        //	 	if null.
        //	event:
        //	 	The name of the event function in obj.
        //	 	I.e. identifies a property obj[event].
        //	example:
        //	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet"};
        var pf = function() {
            dojo.publish(topic, arguments);
        }
        return (event) ? dojo.connect(obj, event, pf) : dojo.connect(obj, pf); //Handle
    };

}
